/**
 * @author liuchangling
 * @date 2021/3/24 3:41 PM
 * @descripion 黑子为0，白子为1
 */

import java.util.Scanner;


public class Chess {
    /**
     * 定义一个二维数组，且横纵长度都为17
     */
    private char[][] arr = new char[17][17];
    /**
     * 定义4个变量，48为0的ascii值，97为a的ascii值；
     * 定义两个的目的，是分别在arr[0][x]、arr[y][0]分别使用
     */
    private char temp1 = 48;
    private char temp3 = 48;
    private char temp2 = 97;
    private char temp4 = 97;
    /**
     * 用于控制黑子白子顺序,true时黑子，false时白子
     */
    private boolean swap = true;
    /**
     * 用于判断是否胜利，true时为胜利，false时为未胜利
     */
    private boolean flag = false;

    /**
     * 构造方法，构造棋盘
     */
    Chess() {
        setChess();
        displayChess();
    }

    /**
     * 设置棋盘
     */
    public void setChess() {
        //i代表行数(即y轴坐标)，j代表列数(x轴坐标)
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                //首先判断是否是第一行，是的话做特殊处理，方便赋值0~f
                if (i == 0) {
                    //i=0且j=0，即左上角的值，使用空格代替
                    if (j == 0) {
                        arr[i][j] = 032;
                    }
                    //当位于第一行，且第一行的横坐标值（j）满足0<j<=10时，循环赋值0~9
                    else if (j > 0 && j <= 10) {
                        arr[i][j] = temp1;
                        temp1++;
                    }
                    //当位于第一行，且第一行的横坐标值满足j>10，循环赋值a~f
                    else {
                        arr[i][j] = temp2;
                        temp2++;
                    }
                }
                //位于第2行~第11行时（第一行i=0,所以是2~11）
                else if (i > 0 && i <= 10) {
                    //当位于第2行~第11行，并且位于第一列时，循环赋值0~9
                    if (j == 0) {
                        arr[i][j] = temp3;
                        temp3++;
                    }
                    //其余赋值为+
                    else {
                        arr[i][j] = 43;
                    }
                }
                //位于第12行后
                else if (i > 10) {
                    //位于第12行后且位于第一列时，循环赋值a~f
                    if (j == 0) {
                        arr[i][j] = temp4;
                        temp4++;
                    }
                    //其余赋值为+
                    else {
                        arr[i][j] = 43;
                    }
                }
            }
        }
    }

    /**
     * 打印棋盘
     */
    public void displayChess() {
        //循环打印arr数组
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println("\n");
        }
    }

    /**
     * 开始下棋：黑白方轮流下棋，并判断下棋的位置是否有棋子
     */
    public void playChess() {
        Scanner scanner = new Scanner(System.in);
        //行列号码
        char row, column;
        while (false == flag) {
            if (swap) {
                System.out.println("请黑子下棋，输入您要落子的行号(0~9，a~e)：");
                row = scanner.next().charAt(0);
                System.out.println("请黑子下棋，输入您要落子的列号(0~9，a~e)：");
                column = scanner.next().charAt(0);

                //需要分为四种情况分别考虑，1.row和column都是数字;2.row是数字，column是字母；3.row是字母，column是数字;4.row和column都是字母
                // 1.row和column都是数字时,‘48’为 0,‘57’为 9
                if (row >= 48 && row <= 57 && column >= 48 && column <= 57) {
                    if (arr[row - 47][column - 47] == 43) {
                        arr[row - 47][column - 47] = 48;
                        swap = false;
                        displayChess();
                        jungle();
                    } else {
                        System.out.println("此处已有棋子，请选择其它位置落子");
                        continue;
                    }
                }
                //2.row是数字0-9，column是字母a-e
                else if (row >= 48 && row <= 57 && column >= 97 && column <= 102) {
                    if (arr[row - 47][column - 86] == 43) {
                        arr[row - 47][column - 86] = 48;
                        swap = false;
                        displayChess();
                        jungle();
                    } else {
                        System.out.println("此处已有棋子，请选择其它位置落子");
                        continue;
                    }
                }
                //3.row是字母，column是数字
                else if (row >= 97 && row <= 102 && column >= 48 && column <= 57) {
                    if (arr[row - 86][column - 47] == 43) {
                        arr[row - 86][column - 47] = 48;
                        swap = false;
                        displayChess();
                        jungle();
                    } else {
                        System.out.println("此处已有棋子，请选择其它位置落子");
                        continue;
                    }
                }
                //4.row和column都是字母
                else if (row >= 97 && row <= 102 && column >= 97 && column <= 102) {
                    if (arr[row - 86][column - 86] == 43) {
                        arr[row - 86][column - 86] = 48;
                        swap = false;
                        displayChess();
                        jungle();
                    } else {
                        System.out.println("此处已有棋子，请选择其它位置落子");
                        continue;
                    }
                } else {
                    System.out.println("输入位置不合法，请按照提示重新输入");
                    continue;
                }
            } else if (!swap) {
                System.out.println("请白子下棋，输入您要落子的横坐标：");
                row = scanner.next().charAt(0);
                System.out.println("请白子下棋，输入您要落子的纵坐标：");
                column = scanner.next().charAt(0);
                // 1.row和column都是数字时,‘48’为 0,‘57’为 9
                if (row >= 48 && row <= 57 && column >= 48 && column <= 57) {
                    if (arr[row - 47][column - 47] == 43) {
                        arr[row - 47][column - 47] = 49;
                        swap = true;
                        displayChess();
                        jungle();
                    } else {
                        System.out.println("此处已有棋子，请选择其它位置落子");
                        continue;
                    }
                }
                //2.row是数字0-9，column是字母a-e
                else if (row >= 48 && row <= 57 && column >= 97 && column <= 102) {
                    if (arr[row - 47][column - 86] == 43) {
                        arr[row - 47][column - 86] = 49;
                        swap = true;
                        displayChess();
                        jungle();
                    } else {
                        System.out.println("此处已有棋子，请选择其它位置落子");
                        continue;
                    }
                }
                //3.row是字母，column是数字
                else if (row >= 97 && row <= 102 && column >= 48 && column <= 57) {
                    if (arr[row - 86][column - 47] == 43) {
                        arr[row - 86][column - 47] = 49;
                        swap = true;
                        displayChess();
                        jungle();
                    } else {
                        System.out.println("此处已有棋子，请选择其它位置落子");
                        continue;
                    }
                }
                //4.row和column都是字母
                else if (row >= 97 && row <= 102 && column >= 97 && column <= 102) {
                    if (arr[row - 86][column - 86] == 43) {
                        arr[row - 86][column - 86] = 49;
                        swap = true;
                        displayChess();
                        jungle();
                    } else {
                        System.out.println("此处已有棋子，请选择其它位置落子");
                        continue;
                    }
                }
            }
        }
    }

    /**
     * 判断是否胜利，4种判断方法：1.横向判断、2.纵向判断、3.左上角到右下角判断、4.从右上角到左下角判断
     */
    public void jungle() {
        for (int i = 1; i < arr.length; i++) {
            for (int j = 1; j < arr[i].length; j++) {
                //1.横向判断是否有连续五个相同棋子
                //判断j<13是因为要兼顾数组的下标取值范围，并且若j=13，则后边只有四个棋子，只考虑横向情况，不可能会赢
                if (j <= 12) {
                    // 此处5个为黑子
                    if (arr[i][j] == 48 && arr[i][j + 1] == 48 && arr[i][j + 2] == 48 && arr[i][j + 3] == 48 && arr[i][j + 4] == 48) {
                        System.out.println("黑子获胜，游戏结束");
                        flag = true;
                        return;
                    }
                    //此处为5个白子
                    if (arr[i][j] == 49 && arr[i][j + 1] == 49 && arr[i][j + 2] == 49 && arr[i][j + 3] == 49 && arr[i][j + 4] == 49) {
                        System.out.println("白子获胜，游戏结束");
                        flag = true;
                        return;
                    }
                }
                //2.纵向判断是否有连续五个相同棋子
                if (i <= 12) {
                    if (arr[i][j] == 48 && arr[i + 1][j] == 48 && arr[i + 2][j] == 48 && arr[i + 3][j] == 48 && arr[i + 4][j] == 48) {
                        System.out.println("黑子获胜，游戏结束");
                        flag = true;
                        return;
                    }
                    if (arr[i][j] == 49 && arr[i + 1][j] == 49 && arr[i + 2][j] == 49 && arr[i + 3][j] == 49 && arr[i + 4][j] == 49) {
                        System.out.println("白子获胜，游戏结束");
                        flag = true;
                        return;
                    }
                }
                //3.左上角到右下角判断
                //判断i,j是否小于等于12，是因为一方面要考虑数组的下标范围，另一方面当棋子位于13(包括13)以后，只有四个棋子，无论如何不会赢
                if (i <= 12 && j <= 12) {
                    if (arr[i][j] == 48 && arr[i + 1][j + 1] == 48 && arr[i + 2][j + 2] == 48 && arr[i + 3][j + 3] == 48 && arr[i + 3][j + 3] == 48 && arr[i + 4][j + 4] == 48) {
                        System.out.println("黑子获胜，游戏结束");
                        flag = true;
                        return;
                    }
                    if (arr[i][j] == 49 && arr[i + 1][j + 1] == 49 && arr[i + 2][j + 2] == 49 && arr[i + 3][j + 3] == 49 && arr[i + 4][j + 4] == 49) {
                        System.out.println("白子获胜，游戏结束");
                        flag = true;
                        return;
                    }
                }
                //4.从右上角到左下角判断
                if (i <= 12 && j >= 5) {
                    if (arr[i][j] == 48 && arr[i + 1][j - 1] == 48 && arr[i + 2][j - 2] == 48 && arr[i + 3][j - 3] == 48 && arr[i + 4][j - 4] == 48) {
                        System.out.println("黑子获胜，游戏结束");
                        flag = true;
                        return;
                    }
                    if (arr[i][j] == 49 && arr[i + 1][j - 1] == 49 && arr[i + 2][j - 2] == 49 && arr[i + 3][j - 3] == 49 && arr[i + 4][j - 4] == 49) {
                        System.out.println("白子获胜，游戏结束");
                        flag = true;
                        return;
                    }
                }
            }
        }
    }
}
